.TH std::move_only_function 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::move_only_function \- std::move_only_function

.SH Synopsis
   Defined in header <functional>
   template< class... >                                    \fB(1)\fP (since C++23)
   class move_only_function; // not defined
   template< class R, class... Args >

   class move_only_function<R(Args...)>;
   template< class R, class... Args >
   class move_only_function<R(Args...) noexcept>;
   template< class R, class... Args >
   class move_only_function<R(Args...) &>;
   template< class R, class... Args >
   class move_only_function<R(Args...) & noexcept>;
   template< class R, class... Args >
   class move_only_function<R(Args...) &&>;
   template< class R, class... Args >
   class move_only_function<R(Args...) && noexcept>;       \fB(2)\fP (since C++23)
   template< class R, class... Args >
   class move_only_function<R(Args...) const>;
   template< class R, class... Args >
   class move_only_function<R(Args...) const noexcept>;
   template< class R, class... Args >
   class move_only_function<R(Args...) const &>;
   template< class R, class... Args >
   class move_only_function<R(Args...) const & noexcept>;
   template< class R, class... Args >
   class move_only_function<R(Args...) const &&>;
   template< class R, class... Args >

   class move_only_function<R(Args...) const && noexcept>;

   Class template std::move_only_function is a general-purpose polymorphic function
   wrapper. std::move_only_function objects can store and invoke any constructible (not
   required to be move constructible) Callable target — functions, lambda expressions,
   bind expressions, or other function objects, as well as pointers to member functions
   and pointers to member objects.

   The stored callable object is called the target of std::move_only_function. If a
   std::move_only_function contains no target, it is called empty. Unlike
   std::function, invoking an empty std::move_only_function results in undefined
   behavior.

   std::move_only_functions supports every possible combination of cv-qualifiers,
   ref-qualifiers, and noexcept-specifiers not including volatile provided in its
   template parameter. These qualifiers and specifier (if any) are added to its
   operator().

   std::move_only_function satisfies the requirements of MoveConstructible and
   MoveAssignable, but does not satisfy CopyConstructible or CopyAssignable.

.SH Member types

   Type        Definition
   result_type R

.SH Member functions

   constructor   constructs a new std::move_only_function object
   (C++23)       \fI(public member function)\fP
   destructor    destroys a std::move_only_function object
   (C++23)       \fI(public member function)\fP
   operator=     replaces or destroys the target
   (C++23)       \fI(public member function)\fP
   swap          swaps the targets of two std::move_only_function objects
   (C++23)       \fI(public member function)\fP
   operator bool checks if the std::move_only_function has a target
   (C++23)       \fI(public member function)\fP
   operator()    invokes the target
   (C++23)       \fI(public member function)\fP

.SH Non-member functions

   swap(std::move_only_function) overloads the std::swap algorithm
   (C++23)                       \fI(function)\fP
   operator==                    compares a std::move_only_function with nullptr
   (C++23)                       \fI(function)\fP

.SH Notes

   Implementations may store a callable object of small size within the
   std::move_only_function object. Such small object optimization is effectively
   required for function pointers and std::reference_wrapper specializations, and can
   only be applied to types T for which std::is_nothrow_move_constructible_v<T> is
   true.

   If a std::move_only_function returning a reference is initialized from a function or
   function object returning a prvalue (including a lambda expression without a
   trailing-return-type), the program is ill-formed because binding the returned
   reference to a temporary object is forbidden. See also std::function Notes.

        Feature-test macro       Value    Std           Feature
   __cpp_lib_move_only_function 202110L (C++23) std::move_only_function

.SH Example


// Run this code

 #include <functional>
 #include <future>
 #include <iostream>

 int main()
 {
     std::packaged_task<double()> packaged_task([](){ return 3.14159; });

     std::future<double> future = packaged_task.get_future();

     auto lambda = [task = std::move(packaged_task)]() mutable { task(); };

 //  std::function<void()> function = std::move(lambda); // Error
     std::move_only_function<void()> function = std::move(lambda); // OK

     function();

     std::cout << future.get();
 }

.SH Output:

 3.14159

.SH See also

   function wraps callable object of any copy constructible type with specified
   \fI(C++11)\fP  function call signature
            \fI(class template)\fP
